/**
 * GroupObj
 *
 */
if(typeof (module) !="undefined"){
    module.exports = GroupObj;

    var PrintObj = require('./PrintObj');
    var Serializer = require('./Serializer');
    var GraphObj = require('./GraphObj');
    var Parser = require('./Parser');
}





function GroupObj()
{
    PrintObj.call(this);    // 继承

    this.sub= new Array(); // 保存对象
    //this.scale = 1.0;
    this.mask=null; // mask  剪切蒙版的轮廓，GraphObj



    this.ct = Serializer.prototype.CLASS_TYPE_GROUPOBJ;
}
GroupObj.prototype = new PrintObj(); // 继承

// 转成json字符串
GroupObj.prototype.toJson = function(){
    // 去掉父json字符串的头尾
    var superJson = PrintObj.prototype.toJson.call(this);
    superJson = superJson.substr(1,superJson.length-2);

    var ret = '{';
    ret +=superJson;
    ret +=',';
    // 对于group的子对象，在undo情况下只记录其id即可，在文档保存的情况下需要记录子对象的数据
    ret +=('"sub":'+'[');

    for(var m=0;m<this.sub.length;m++){
        if(m>0){
            ret +=',';
        }
        ret += this.sub[m].toJson();
    }

    ret +=']';

    if(this.mask){
        ret +=',';
        ret +=('"mask":'+this.mask.toJson());
    }
    ret+='}';
    return ret;
}
// 从json对象中解析出PointPath
GroupObj.prototype.fromJson = function(jsonObj, versionId){
    PrintObj.prototype.fromJson.call(this, jsonObj,versionId);

    for(var m=0;m<jsonObj.sub.length;m++){
        var obj = Parser.prototype.fromUnknownJson.call(this, jsonObj.sub[m], versionId);
        this.sub.push(obj);
    }

    if(jsonObj.hasOwnProperty("mask") && jsonObj.mask !=null){
            var maskObj = new GraphObj();
            maskObj.fromJson(jsonObj.mask,versionId);
            this.mask = maskObj;
    }
}

/**
 * 将对象添加到PDF中
 * @param doc  PDFDocument结构
 * @param info  对象结构，属性如下：
 *                  docOriginX  文档的新原点 在原始原点的 坐标
 *                  docOriginY  文档的新原点 在原始原点的 坐标
 *                  w   文档宽度
 *                  h   文档高度
 */
GroupObj.prototype.addToPdf = function(doc, info){
    // 保存上下文环境
    Serializer.prototype.before.call(this, doc, info);

    doc.opacity(this.al);
    // 描绘 剪切蒙版
    if(this.mask){
        // 添加剪切蒙版
        var svgPath = this.mask.cp.toSvgPath();
        doc.path(svgPath).clip();

        // 描绘 组的对象
        for(var m=0;m<this.sub.length;m++){
            var obj = this.sub[m];
            obj.addToPdf(doc,info);
        }
    }else{
        // 描绘 组的对象
        for(var m=0;m<this.sub.length;m++){
            var obj = this.sub[m];
            obj.addToPdf(doc,info);
        }

    }




    // 还原上下文环境
    Serializer.prototype.after.call(this, doc,info);
}

// 取得子模板对象(返回subTemplateObj数组)
GroupObj.prototype.getSubTemplateObj= function(key)
{
    var ret = new Array();
    for(var i=0;i<this.sub.length;i++){
        var subRet = this.sub[i].getSubTemplateObj(key);
        for(var j=0;j<subRet.length;j++){
            ret.push(subRet[j]);
        }
    }

    return ret;
}
// 取得对象的叶节点
GroupObj.prototype.getLeafObjs= function(){
    var ret = new Array();
    for(var m=0;m<this.sub.length;m++){
        var o=this.sub[m];
        var subRet= o.getLeafObjs();
        if(subRet && subRet.length>0){
            for(var n=0;n<subRet.length;n++){
                ret.push(subRet[n]);
            }
        }
    }
    return ret;
}

/**
 * 取得模板中所有文字的轮廓 的di,
 * 返回：数组
 */
GroupObj.prototype.getTextContourDis = function(){
    var ret = new Array();
    for(var m=0;m<this.sub.length;m++){
        var o=this.sub[m];
        var subRet= o.getTextContourDis();
        if(subRet && subRet.length>0){
            for(var n=0;n<subRet.length;n++){
                ret.push(subRet[n]);
            }
        }
    }
    return ret;
}
/**
 * 设置所有文字的轮廓
 * 参数：vectors： TVectorModel类型的数组
 */
GroupObj.prototype.setTextContour = function(vectors){
    for(var i=0;i<this.sub.length;i++){
        this.sub[i].setTextContour(vectors);
    }
}

/**
 * 取得模板中所有文字对象,
 * 参数：ignoreEmptyDi，true表示需要过滤掉无效di的文字对象
 * 返回：数组
 */
GroupObj.prototype.getTextObjs = function(ignoreEmptyDi){
    var ret = new Array();
    for(var m=0;m<this.sub.length;m++){
        var o = this.sub[m].getTextObjs(ignoreEmptyDi);
        for(var n=0;n< o.length;n++){
            ret.push(o[n]);
        }
    }

    return ret;
}
/**
 * 取得模板中所有图形对象,
 * 参数：ignoreEmpty   Di，true表示需要过滤掉无效di的文字对象
 * 返回：数组
 */
GroupObj.prototype.getGraphObjs = function(ignoreEmptyDi){
    var ret = new Array();
    for(var m=0;m<this.sub.length;m++){
        var o = this.sub[m].getGraphObjs(ignoreEmptyDi);
        for(var n=0;n< o.length;n++){
            ret.push(o[n]);
        }
    }

    return ret;
}
/**
 * 取得编组中所有图片对象,
 * 返回：数组
 */
GroupObj.prototype.getImageObjs = function(){
    var ret = new Array();
    for(var m=0;m<this.sub.length;m++){
        var o = this.sub[m].getImageObjs();
        for(var n=0;n< o.length;n++){
            ret.push(o[n])
        }
    }
    return ret;
}

/**
 * 取得编组中所有图片对象,
 * 参数：
 *      shadowImage：图片阴影对象(ImageObj)
 * 返回：true表示找到并且插入
 *
 */
GroupObj.prototype.insertShadowImgObj = function(shadowImage){
    for(var m=0;m<this.sub.length;m++){
        var o = this.sub[m];
        // 比较o和newImage.from是否相等
        if(o== shadowImage.from){
            // 如果相等，则将newImage插入到o下方，退出
            this.sub.splice(m,0,shadowImage);
            return true;
        }else{
            // 如果不等，则调用o的insertObj
            var ret = o.insertShadowImgObj(shadowImage);
            if(ret)
                return ret;
        }
    }
    return false;
}
/**
 * 设置颜色模式
 */
GroupObj.prototype.setColorMode = function(cm){
    PrintObj.prototype.setColorMode.call(this, cm);
    for(var j=0; j<this.sub.length; j++){
        var printObj = this.sub[j];
        printObj.setColorMode(cm);
    }
}

/** 简化可替换group,将子对象中非可替换部分删除
 * 返回：true表示是可替换对象，false表示无
 */
GroupObj.prototype.simplifyReplaceGroup = function (){
    var ret = false;
    for(var j=this.sub.length-1; j>=0; j--){
        var printObj = this.sub[j];
        if(printObj.simplifyReplaceGroup()){
            ret = true;
        }else{
            this.sub.splice(j,1);// 删除子
        }
    }
    // 如果含有可删除子这不需要删除mask，否则需要删除
    if(!ret){
        this.mask = null;
    }

    return ret;
}